﻿#include <iostream>
#include <string>
using namespace std;


//继承


//父类、基类
//class Person
//{
//public:
//	void Print()
//	{
//		cout << "name :" << _name << endl;
//		cout << "age :" << _age << endl;
//	}
//
////private:
////protected:
//	string _name = "Peter";
//	int _age = 18; 
//};
//
//////学生类
//class Student : public Person
//{
//public:
//	void func()
//	{
//		Print();
//	}
//protected:
//	int _stuid;//学号
//};
////
//////老师类
//class Teacher : public Person
//{
//protected:
//	int _jobid;//工号
//};
//int main()
//{
//	Person p;
//	p.Print();
//	cout << endl<<endl;
//
//	Student s;
//	cout << sizeof(s) << endl;
//	s._age = 10; //父类成员变量是private 和 protected 不能修改
//	s.Print();
//	s.func();
//
//	//cout << endl << endl;
//
//	//Teacher t;
//	//t.Print();
//	//cout << endl << endl;
//
//	return 0;
//}

//class Person
//{
//public:
//	void Print()
//	{
//		cout << "name:" << _name << endl;
//		cout << "age:" << _age << endl;
//		cout << "ID:" << _ID << endl;
//	}
//public:
//	string _name = "张三";
//
//protected:
//	int _age = 18;
//
//private:
//	int _ID = 1;
//};
//
//class Student : public Person
//{
//
//};
//
//int main()
//{
//	Student st;
//	st.Print();
//	st._name = "李四";
//	st._age;
//	st._ID;
//
//
//	return 0;
//}

//class Person
//{
//
////protected:
//public:
//	string _name; // 姓名
//	string _sex;  // 性别
//	int	_age;	 // 年龄
//};
//
//class Student : public Person
//{
//public:
//	int _No; // 学号
//};
//int main()
//{
//	Person p;
//	Student s;
//	//1.子类对象给父类 对象/指针/引用 -- 语法天然支持，没有类型转换 
//	p = s;				//对象
//	Person& rp = s;		//引用
//	Person* ptrp = &s;	//指针
//
//	//2.基类对象不能赋值给派生类对象
//	//s = p;
//
//
//
//	ptrp = &s;
//	Student* ps1 = (Student*)ptrp;//这种情况下转换是可以的
//	ps1->_No = 10;
//
//	ptrp = &p;
//	Student* ps2 = (Student*)ptrp;//这种情况转换时虽然可以，但是会存在越界访问的问题
//	ps2->_No = 10;
//
//
//	s._name = "张三";
//	s._age = 18;
//	s._sex = "男";
//
//
//
//	cout << &s << endl;
//	cout << &rp << endl;
//	cout << ptrp << endl;
//	rp._age++;
//	ptrp->_age++;
//
//
//	//s = (Student)p;  //不支持强制类型转换
//
//
//	return 0;
//}

//隐藏
//Student的_num和Person的_num构成隐藏关系，
//可以看出这样代码虽然能跑，但是非常容易混淆
//尽量避免重名
//class Person
//{
//protected:
//	string _name = "张三"; // 姓名
//	int _num = 111; 	    // 身份证号
//};
//
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << " 姓名:" << _name << endl;
//		cout << " 学号:" << _num << endl;//会使用自己的成员变量 999
//		cout << " 身份证号:" << Person::_num << endl; //要指定作用域
//	}
//protected:
//	int _num = 999; // 学号
//};
//int main()
//{
//	Student s;
//	s.Print();
//	return 0;
//}
//
////两个fun关系是隐藏
//class A
//{
//public:
//	void fun()
//	{
//		cout << "A::func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun()
//	{
//		cout << "B::func()"<< endl;
//	}
//};
//
//int main()
//{
//	B b;
//	b.fun();//b的fun()隐藏了A的fun()
//	b.A::fun();//指定作用域即可访问到A的func()
//	return 0;
//};

// A::fun 和 B::fun 的关系 -> 隐藏
// 函数重载要求在同一作用域
//class A
//{
//public:
//	void fun()
//	{
//		cout << "A::func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "B::func(int i)" << endl;
//	}
//};
//
//int main()
//{
//	B b;
//	//b.fun();  // 构成隐藏，编译报错
//	b.A::fun();
//	b.fun(1);
//
//	return 0;
//};


//class Person
//{
//public:
//	Person(const char* name)
//		:_name(name)
//	{
//		cout << "Person(const char* name)" << endl;
//	}
//	拷贝构造
//	Person(const Person& p)
//		:_name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	}
//	
//	赋值拷贝
//	Person& operator=(const Person& p)
//	{
//		cout << "Person& operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//
//		return *this;
//	}
//
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//
//protected:
//	string _name;//姓名
//};
//
//class Student : public Person
//{
//public:
//	Student(const char* name = "", int num = 0)
//		:_num(num)
//		,Person(name)
//	{
//		cout << "Student(const char* name = "", int num = 0)" << endl;
//	}
//
//	拷贝构造
//	Student(const Student& s)
//		:Person(s)
//		,_num(s._num)
//	{
//		cout << "Student(const Student& s)" << endl;
//	}
//
//	赋值构造
//	 s1 = s3
//	Student& operator=(const Student& s)
//	{
//		if (this != &s)
//		{
//			Person::operator=(s);
//			_num = s._num;
//		}
//		cout << "Student& operator=(const Student& s)" << endl;
//
//		return *this;
//	}
//
//	父类和子类析构函数构成隐藏关系
//	原因：多态的需要，析构函数名同意会被处理成destructor()
//	为了保证析构的顺序，先子后父
//	子类析构函数完成后会自动调用父类析构函数,所以不需要我们显示调用
//	~Student()
//	{
//		父类的析构函数我们不需要显示调用
//		Person::~Person();
//		cout << "~Student()" << endl;
//	}
//protected:
//	int _num; //学号
//
//};
//
//子类构造函数原则:
//a、调用父类构造函数初始化继承自父类成员
//b、自己再初始化自己的成员--规则参考普通类
// 析构、拷贝构造、复制重载也类似
//
//int main()
//{
//	Student s1("李四", 1);
//	Student s2(s1);
//
//	Student s3("王五", 2);
//	s1 = s3;
//
//	return 0;
//}


//如何设计一个不能被继承的类
//思路：父类的构造函数私有化即可
//class A
//{
//public:
//	//提供给一个接口
//	static A CreateBoj()
//	{
//		return A();
//	}
//private:
//	A()
//	{}
//
//};
//
//class B : public A
//{
//
//};
//int main()
//{
//	//B b;
//	A a = A::CreateBoj();
//
//	return 0;
//}

//继承不能传递友元


//class Student;
//class Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);
//protected:
//	string _name; // 姓名
//};
//
//class Student : public Person
//{
//	friend void Display(const Person& p, const Student& s);
//protected:
//	int _stuNum; // 学号
//};
//
//void Display(const Person& p, const Student& s)
//{
//	cout << p._name << endl;
//	//要想访问到Student中的保护成员，要提供友元函数
//	cout << s._stuNum << endl;
//}
//
//int main()
//{
//	Person p;
//	Student s;
//	Display(p, s);
//
//	return 0;
//}

// 单继承
//class Person
//{
//public:
//	Person() { ++_count; }
//protected:
//	string _name; // 姓名
//public:
//	static int _count; // 统计人的个数。
//};
//
//int Person::_count = 0;
//
//class Student : public Person
//{
//protected:
//	int _stuNum; // 学号
//};
//
//class Graduate : public Student
//{
//protected:
//	string _seminarCourse; // 研究科目
//};
////
//int main()
//{
//	Student s1;
//	Student s2;
//	Student s3;
//	Graduate s4;
//	Person s;
//
//	cout << " 人数 :" << Person::_count << endl;
//	cout << " 人数 :" << Student::_count << endl;
//	cout << " 人数 :" << s4._count << endl;
//
//	//同一个地址
//	cout << " 人数 :" << &Person::_count << endl;
//	cout << " 人数 :" << &Student::_count << endl;
//	cout << " 人数 :" << &s4._count << endl;
//
//	return 0;
//}

//多继承
//            Person
//  
//    Student        Teacher
// 
//           Assistant

//class Person
//{
//public:
//	string _name; // 姓名
//	int _a[10000]; //会有多份_a
//};
//class Student : virtual public Person
//{
//protected:
//	int _num; //学号
//};
//class Teacher : virtual public Person
//{
//protected:
//	int _id; // 职工编号
//};
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程
//};
////
//int main()
//{
//	// 这样会有二义性无法明确知道访问的是哪一个
//	Assistant a;
//	a._name = "peter";
//
//	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
//	a.Student::_name = "xxx";
//	a.Teacher::_name = "yyy";
//
//	cout << sizeof(a) << endl;
//
//	return 0;
//}

//
//class A
//{
//public:
//	int _a;
//	//static int _a;
//};
//
////int A::_a = 0;
//
////class B : public A
//class B : virtual public A
//{
//public:
//	int _b;
//};
//
////class C : public A
//class C : virtual public A
//{
//public:
//	int _c;
//};
//
//class D : public B, public C
//{
//public:
//	int _d;
//};
//
//int main()
//{
//	D d;
//	d._a = 0;
//	d.B::_a = 1;
//	d.C::_a = 2;
//	d._b = 3;
//	d._c = 4;
//	d._d = 5;
//
//	//D d1;
//	//D d2;
//	//cout << &d1._a << endl;
//	//cout << &d2._a << endl;
//
//	B b;
//	b._a = 10;
//	b._b = 20;
//
//	B* ptr1 = &d;
//	B* ptr2 = &b;
//
//	//ptr1和ptr2不知道自己指向的是b还是d
//	//在d对象里面,A成员跟B的距离远：20
//	//在b对象里面,A成员跟B的距离近：8
//	//ptr1和ptr2无法知道也不关心自己指向的是谁！
//	//都使用同样的方式去找A成员,先找到虚基表中的偏移量
//	//然后计算A的位置
//	cout << ptr1->_a << endl;
//	cout << ptr2->_a << endl;
//	cout << ptr1->_b << endl;
//	cout << ptr2->_b << endl;
//
//	return 0;
//}


// Car和BMW Car和Benz构成is-a的关系
class Car {
protected:
	string _colour = "白色"; // 颜色
	string _num = "陕ABIT00"; // 车牌号
};

class BMW : public Car {
public:
	void Drive() { cout << "好开-操控" << endl; }
};

class Benz : public Car {
public:
	void Drive() { cout << "好坐-舒适" << endl; }
};

// Tire和Car构成has-a的关系

class Tire {
protected:
	string _brand = "Michelin";  // 品牌
	size_t _size = 17;         // 尺寸
};

class Car {
protected:
	string _colour = "白色"; // 颜色
	string _num = "陕ABIT00"; // 车牌号
	Tire _t; // 轮胎
};